//引入公共函数模块
let util = require('../../utils/util');

//引入WebSocket操作模块
let ws = require('../../utils/websocket');

//用于存储Page this
let that;

//获取到APP实例
let app = getApp();

//执行Page初始化页面
Page({

  //页面数据变量
  data:{

    //是否连接失败
    connectFailed: false,

    //是否锁定登录按钮
    loginBtnDisabled: false,

    //是否处于进入聊天界面状态
    startChat: false,

    //绑定到聊天列表的变量
    userListData: {},

    empty: true

  },

  /**
   * 初次加载页面触发函数
   */

  onLoad: function(params){

    //判断是否未登录商户
    if(!util.globalData('storeId')) {

      util.showError('系统错误', '未验证的商户')

      return;

    }

    wx.showToast({
      title: '加载数据中',
      icon: 'loading',
      mask: true,
      duration: 10000
    });

    //取得页面实例
    that = this;

    //绑定消息触发的函数
    util.target('sysMsg', that.sysMsgHandler);
    util.target('userMsg', that.userMsgHandler);
    
    //执行聊天记录恢复函数
    that.recoverChat();

    //获得未读消息
    let loginData = util.globalData('loginData');

    //恢复未读消息到界面
    that.recoverUnreadMsg(loginData.unreadMsgs);
    
    loginData.unreadMsgs = [];

    util.globalData('loginData', loginData);

  },

   /**
   * 页面显示触发函数
   */

  onShow: function() {

    //隐藏加载图标
    wx.hideNavigationBarLoading();

    if(Object.keys(that.data.userListData).length > 0) {
      that.setData({empty: false});
    }
    else {
        wx.showToast({
            title: '加载数据中',
            icon: 'loading',
            mask: true
        });
        wx.hideToast();
    }

    //判断页面是否跳转过了
    if(!util.status('pageInit')) {

      //初始化完成
      util.status('pageInit', true);

      //切换页面到服务页面
      wx.switchTab({

          //切换的页面路径
          url: '/pages/service/service',

          //切换页面失败
          fail: function(err) {
              
              console.log(err);

              //显示切换页面失败的错误
              util.showError('切换页面失败', '小程序切换页面时出错，请重试');

          }
      });
    }

    //设置当前的连接状态
    that.setData({connectFailed: !util.status('connected')});

    if(!util.status('connected')) {
        util.status('recryConnectDone', true);
        app.wsClose();
    }

    //判断当前是否是从聊天界面退出来
    if(that.data.startChat) {

      //将处于聊天界面的状态解除
      that.data.startChat = false;
      
      //取得刚刚进行聊天的用户的ID
      var userId = util.globalData('clearUnreadMsgUser');

      //同步当前用户已列表为公共的用户列表数据
      that.setData({userListData: app.globalData.userListData});

      //判断是否存在用户ID以及存在此用户的聊天数据
      if(userId && that.data.userListData[userId]) {

        //设置未读聊天记录个数为0
        that.data.userListData[userId].userUnreadMsgCount = 0;
        
        //同步更新的聊天数据
        that.setData({userListData: that.data.userListData});

        //存储用户聊天数据到本地缓存
        wx.setStorageSync(userId, that.data.userListData[userId]);

      }
    }
  },

  /**
   * 系统消息处理函数
   */

  sysMsgHandler: function(event, msg) {

    console.log(event, msg);

    //判断消息类型执行对应的操作
    switch(event) {
        case 'wsErrClose':
        case 'wsErrClose':
            that.setData({connectFailed: true});
        break;
        case 'wsRecryConnected':
            let {unreadMsgs} = msg;
            console.log(msg);
            wx.hideNavigationBarLoading();
            that.setData({connectFailed: false});
            //恢复未读消息到界面
            that.recoverUnreadMsg(unreadMsgs);
        break;
    }

  },

  /**
   * 用户消息处理函数
   */

  userMsgHandler: function(event, msg) {

    util.playCue('sound1');

    console.log(event, msg);

    //判断消息事件类型
    switch(event) {
      
      //用户进入微信聊天界面消息
      case 'openMsg':

        //更新用户开启会话数据到界面
        that.setUserData(msg.userId, {
          userName: msg.userName,
          userGender: msg.userGender,
          userPhoto: msg.userPhoto,
          userTableNum: msg.userTableNum,
          userMsg: [ 
            {
              sender: 'user', 
              msg: '我开启了会话', 
              timestamp: msg.msgTimestamp,
              //用户进入聊天时仅有回复一条消息的权限，一般已经由服务器自动回复欢迎消息，所以不能回复
              tipMsg: '等待用户发送消息，您暂时不能发送消息',
              chatTimeTip: '',
              show: true
            }
          ]

        });

        that.setData({empty: false});

      break;

      //用户发送消息
      case 'sendMsg':

        let userChatData =  {

          //发送消息的用户
          userName: msg.userName,

          //发送消息的用户的性别
          userGender: msg.userGender,

          //发送消息的用户的头像
          userPhoto: msg.userPhoto,

          //发送消息的用户的桌号
          userTableNum: msg.userTableNum,
          
          //用户发送的消息
          userMsg: [
            {

              //发送者身份
              sender: 'user', 

              //消息内容
              msg: that.replaceMsgEmoticon(msg.msgContent), 

              timestamp: msg.msgTimestamp,

              //如果已经判别关键字自动回复就需要显示标签
              tipMsg: '',

              chatTimeTip: '',

              show: true

            }
          ]

        };

        if(msg.autoReply) {
          userChatData.userMsg.push({
            sender: 'sys',
            msg: msg.autoReply,
            timestamp: Date.now(),
            tipMsg: '消息已自动回复，您还能发送2条消息',
            sendStatus: '',
            show: true
          });
        }

        //更新用户消息数据到界面
        that.setUserData(msg.userId, userChatData);

        that.setData({empty: false});

      break;

      case 'replyMsg': 

        that.addOtherReply(msg.userId, msg.msg);
        
      break;
    }

  },

  /**
   * 添加其它服务员回复到聊天记录数据
   */

  addOtherReply: function(userId, replyContent) {

    //判断是否存在回复的内容以及存在于该用户的聊天记录数据
    if(replyContent && app.globalData.userListData[userId]) {

      //获得当前时间戳
      var timestamp = Date.now();

      //获取当前的聊天数据作为老旧数据
      var oldMsgList = app.globalData.userListData[userId].userMsg;

      if(oldMsgList[oldMsgList.length - 1].msg == replyContent) {

        console.log('排除一条聊天消息');
        return;

      }

      //往与用户的聊天数据中添加一条服务员发送的消息数据
      app.globalData.userListData[userId].userMsg.push({

        //发送者类型
        sender: 'sys',

        //回复的内容
        msg: replyContent,

        //发送时的时间戳
        timestamp: timestamp,
        
        //此消息的发送时间显示
        chatTimeTip: '' + (oldMsgList[oldMsgList.length - 1] ? (timestamp - oldMsgList[oldMsgList.length - 1].timestamp > 180000 ? util.formatTime(new Date()) : '') : util.formatTime(new Date())),

        //消息的发送状态
        sendStatus: '',

        emoticon: [],

        //此消息是否可见
        show: true

      });

      //将加入回复的聊天数据存入本地缓存
      wx.setStorageSync(userId, app.globalData.userListData[userId]);

    }
  },

  /**
   * 开启聊天界面函数
   */

  startChat: function(e){
    
    //判断当前是否已连接通讯服务器
    if(that.checkConnectStatus()) {
      
      //获取到服务员点击的用户聊天项的id值，即为用户ID
      var userId = e.currentTarget.id;

      //设置此用户的未读消息为0，打开此页面表示已读
      app.globalData.userListData[userId].userUnreadMsgCount = 0;
      that.data.userListData[userId].userUnreadMsgCount = 0;

      //更新未读消息到界面
      that.setData({userListData: that.data.userListData});

      //存储未读消息到本地缓存
      wx.setStorageSync(userId, that.data.userListData[userId]);

      console.log(that.data.userListData[userId]);

      //设置当前已进入了聊天界面
      that.data.startChat = true;

      //切换页面到chat页面并将用户ID也传过去
      util.changePage('chat', {
        //用户ID
        userId: userId
      });

    }
    else {

      //未登录显示错误提示
      util.showError('未连接服务', '抱歉，您当前处于离线状态，请等待重连');

    }
  },

  /**
   * 恢复聊天记录函数
   */

  recoverChat: function() {
    
    //从本地缓存读取参与聊天的用户列表(包含用户ID和最后消息的时间戳)
    let userMsgList = wx.getStorageSync('userMsgList');
    
    //暂存用户ID变量
    var userId = '';
    
    //用户聊天数据使用用户ID作为key
    var userMsgData = {};
    
    //判断聊天用户列表的项个数是否不为空
    if(userMsgList.length > 0) {

      //将用户消息列表根据发送顺序排序
      userMsgList.sort(function(a, b) {

        //根据返回值排序
        return b.msgTimestamp - a.msgTimestamp;

      });

      //遍历参与聊天的用户列表，将聊天记录设置到界面
      for(let index in userMsgList) {

        console.log(userMsgList[index]);
    
        //获取到用户ID
        userId = userMsgList[index].userId;
    
        //获取到对应用户ID的聊天数据
        userMsgData = wx.getStorageSync(userId);

        //判断是否存在此用户的聊天数据
        if(userMsgData) {
    
          //设置此用户的聊天数据到界面上
          that.setUserData(userId, {
    
            //用户昵称
            userName: userMsgData.userName,
    
            //用户性别
            userGender: userMsgData.userGender,
    
            //用户头像
            userPhoto: userMsgData.userPhoto,
    
            //用户桌号
            userTableNum: userMsgData.userTableNum,

            //未读消息数
            userUnreadMsgCount: userMsgData.userUnreadMsgCount,
    
            //用户消息数据，是一个数组
            userMsg: userMsgData.userMsg,

          });
        }
      }
    }
  },

  /**
   * 替换消息中的表情字符为中文意思
   */

   replaceMsgEmoticon: function(msg) {

     //获取表情配置
    var emoticonConfig = util.config('emoticons');
    
    //遍历表情配置列表
    for(var emoticonWord in emoticonConfig) {
      
      //判断此消息内是否存在此表情关键字
      if(msg.indexOf(emoticonWord) != -1) {
        
        //将关键字中的特殊不能参与正则的字符转义为正常字符并进行全部匹配替换
        msg = msg.replace(

          //新建一个正则匹配对象
          new RegExp(emoticonWord
          .replace(')', '\\)')
          .replace('(', '\\(')
          .replace('$', '\\$')
          .replace("'", "\\'")
          .replace('-', '\\-')
          .replace('|', '\\|')
          .replace('@', '\\@')
          .replace('?', '\\?')
          .replace('!', '\\!')
          .replace('*', '\\*')
          , 'g'), '[' + emoticonConfig[emoticonWord].name + ']');

      }
    }

    //返回替换了表情字符的消息
    return msg;

   },

  /**
   * 设置用户聊天数据列表
   */

  setUserData: function(userId, data) {

    console.log(app.globalData.userListData);
    
    //判断是否存在该用户的聊天数据
    if(!app.globalData.userListData[userId]) {
    
      //不存在，设置初始值
      app.globalData.userListData[userId] = {
        
        userName: '',
        userGender: 0,
        userPhoto: 'images/serviceDefaultPhoto.jpg',
        userTableNum: '00',
        userUnreadMsgCount: 0,
        userMsg: []

      };
    
    }

    let userMsgLength = 0;

    //统计用户发送消息个数
    for(index in data.userMsg) {
      if(data.userMsg[index].sender == 'user') {
        userMsgLength++;
      }
    }

    //获得未读消息数量
    var userUnreadMsgCount = util.isSet(data.userUnreadMsgCount) ? data.userUnreadMsgCount : app.globalData.userListData[userId].userUnreadMsgCount + userMsgLength;

    var oldMsgList = app.globalData.userListData[userId].userMsg;

    //暂存需要存放的用户数据变量
    var userData = {
    
      //设置用户昵称
      userName: data.userName,
      
      //设置用户性别
      userGender: data.userGender,
    
      //设置用户头像
      userPhoto: data.userPhoto,
    
      //设置用户桌号
      userTableNum: data.userTableNum,
    
      //设置未读该用户消息的个数
      userUnreadMsgCount: userUnreadMsgCount,
      
      //先设置用户聊天记录为原来的消息记录
      userMsg: oldMsgList,

    };

    console.log(data.userMsg);

    //遍历传入的用户聊天记录数组
    for(var index in data.userMsg) {
      //添加聊天记录
      userData.userMsg.push({
        sender: data.userMsg[index].sender,
        msg: data.userMsg[index].msg,
        timestamp: data.userMsg[index].timestamp,
        tipMsg: data.userMsg[index].tipMsg,
        chatTimeTip: '' + (oldMsgList[oldMsgList.length - 1] ? (data.userMsg[index].timestamp - oldMsgList[oldMsgList.length - 1].timestamp > 180000 ? util.formatTime(new Date(data.userMsg[index].timestamp)) : '') : util.formatTime(new Date(data.userMsg[index].timestamp))),
        sendStatus: data.userMsg[index].sendStatus || '',
        show: data.userMsg[index].show
      });

      //设置用户ID为key用户数据为value的本地缓存
      wx.setStorageSync(userId, userData);

      //获取聊天用户列表
      var userMsgList = wx.getStorageSync('userMsgList');
      
      //当前用户是否存在在聊天用户列表中
      let userFound = false;

      //判断本地缓存中是否存在用户列表
      if(!userMsgList) {
        
        //不存在用户聊天列表则设置一个空数组作为列表
        userMsgList = [];
      
      }
      else {
        
        //存在列表则根据用户列表中的最后一条消息时间戳来进行排序，最近发消息的用户都会被排在前面
        userMsgList.sort(function(a, b) {
          return b.msgTimestamp - a.msgTimestamp;
        });
        
        //遍历用户列表判断当前用户是否在列表中，如果存在则更新其时间戳并设置userFound函数为ture
        for(var userMsgIndex in userMsgList) {
          
          //判断是否对应userId
          if(userMsgList[userMsgIndex].userId == userId) {
            
            //更新最后一条消息时间戳
            userMsgList[userMsgIndex].msgTimestamp = data.userMsg[index].timestamp;

            //设置已找到用户
            userFound = true;

            //跳出循环
            break;

          }
        }
      }

      //判断是否已经找到用户
      if(!userFound) {
        
        //未找到用户则添加此用户到列表并设置最后消息时间戳
        userMsgList.push({
          userId: userId,
          msgTimestamp: data.userMsg[index].timestamp
        });

      }

      //设置用户列表到本地缓存
      wx.setStorageSync('userMsgList', userMsgList);

      //更新公共用户聊天数据列表
      app.globalData.userListData[userId] = userData;

    }

    //设置聊天列表数据到界面
    that.setData({userListData: app.globalData.userListData});
  }, 

  /**
   * 检查当前是否处于登录状态函数
   */

  checkConnectStatus: function() {
    
    //获取登录状态
    if(util.status('connected')) {
      
      //返回已在线
      return true;

    }
    
    //返回未登录
    return false;
  
  },

  /**
   * 恢复推送的未读消息到界面函数
   */

  recoverUnreadMsg: function(unreadMsgs) {

    console.log(unreadMsgs);

    //如果未读消息不是一个数组则跳出
    if(!unreadMsgs || !unreadMsgs[0]) {
      return;
    }

    //预定义存储消息数据的变量
    var msgData = {};

    //遍历推送的未读消息
    for(var msgIndex in unreadMsgs) {
      
      //获得未读消息数据
      msgData = unreadMsgs[msgIndex];
      
      //判断界面中是否存在此用户
      if(!that.data.userListData[msgData.userId]) {
        that.data.userListData[msgData.userId] = {
          //设置用户昵称
          userName: msgData.userName,
          
          //设置用户性别
          userGender: msgData.userGender,
        
          //设置用户头像
          userPhoto: msgData.userPhoto,
        
          //设置用户桌号
          userTableNum: msgData.userTableNum,
        
          //设置未读该用户消息的个数
          userUnreadMsgCount: 0,
          
          //先设置用户聊天记录为原来的消息记录
          userMsg: []
        };
      }

      //替换消息字符串中的表情字符
      unreadMsgs[msgIndex].msg = that.replaceMsgEmoticon(unreadMsgs[msgIndex].msg);

      //将未读的消息推入到该用户的消息列表
      that.data.userListData[msgData.userId].userMsg.push(unreadMsgs[msgIndex]);

      //增加未读消息个数
      that.data.userListData[msgData.userId].userUnreadMsgCount++;

      //同步更新的聊天数据
      that.setData({userListData: that.data.userListData});

      app.globalData.userListData[msgData.userId] = that.data.userListData[msgData.userId];

      //从本地缓存读取参与聊天的用户列表(包含用户ID和最后消息的时间戳)
      let userMsgList = wx.getStorageSync('userMsgList');

      //当前用户是否存在在聊天用户列表中
      let userFound = false;

      //判断本地缓存中是否存在用户列表
      if(!userMsgList) {
        
        //不存在用户聊天列表则设置一个空数组作为列表
        userMsgList = [];
      
      }
      else {
        
        //存在列表则根据用户列表中的最后一条消息时间戳来进行排序，最近发消息的用户都会被排在前面
        userMsgList.sort(function(a, b) {
          return b.msgTimestamp - a.msgTimestamp;
        });
        
        //遍历用户列表判断当前用户是否在列表中，如果存在则更新其时间戳并设置userFound函数为ture
        for(var userMsgIndex in userMsgList) {
          
          //判断是否对应userId
          if(userMsgList[userMsgIndex].userId == msgData.userId) {
            
            //更新最后一条消息时间戳
            userMsgList[userMsgIndex].msgTimestamp = parseInt(msgData.timestamp);

            //设置已找到用户
            userFound = true;

            //跳出循环
            break;

          }
        }
      }

      //判断是否已经找到用户
      if(!userFound) {
        
        //未找到用户则添加此用户到列表并设置最后消息时间戳
        userMsgList.push({
          userId: msgData.userId,
          msgTimestamp: parseInt(msgData.timestamp)
        });

      }
      
      wx.setStorageSync('userMsgList', userMsgList);
      wx.setStorageSync(msgData.userId, app.globalData.userListData[msgData.userId]);
    }
  }

});